import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
tf.__version__
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
##保存图片
def save_image(img,file_name):
PIL.Image.fromarray(np.array(img)).save(file_name)
##定义噪声图片
img_noise = np.random.uniform(size=(300,300,3))+100.##300X300的三通道图片
img_noise = img_noise.astype(np.float32)
show_image(normalize_image(img_noise))
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
#base_model.summary()
[InternetShortcut]
URL=http://localhost:8888/notebooks/DIYDay11_DeepDream.ipynb#DeepDream��Ҫ�뷨��ѡ��һ����������ij��ͨ���������㣨Ҳ�����Ƕ��������㣩���ı�ͼ�����أ���������ѡ�в���ͨ���ļ���ֵ��
[InternetShortcut.A]
URL=http://localhost:8888/notebooks/DIYDay11_DeepDream.ipynb#DeepDream��Ҫ�뷨��ѡ��һ����������ij��ͨ���������㣨Ҳ�����Ƕ��������㣩���ı�ͼ�����أ���������ѡ�в���ͨ���ļ���ֵ��
[InternetShortcut.W]
URL=http://localhost:8888/notebooks/DIYDay11+AF8-DeepDream.ipynb+ACM-DeepDream+TjuJgWDzbNVmL5AJYulOAE4qU3d571xCdoRn0E4qkBqQU2IWU3d571xC/whOX1PvTuVmL1kaTip/UX7cXEL/Cf8MZTlT2Fb+UM9Qz30g/wxnZWcAWSdTFpAJTi1cQmIWkBqQU3aEb8BtO1A8MAI-
layer_name="conv2d_85"
layers = base_model.get_layer(layer_name).output
layers
##创建特征提取模型
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
#dream_model.summary()
##计算损失
def calc_loss(img,model):
channel =13#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
act = layer_activations[:,:,:,channel]
loss = tf.math.reduce_mean(act)##要使loss越来越大
return loss
## 图像优化过程
def render_deepdream(model,img,steps=100,step_size=0.01,verbose=1):
for n in tf.range(steps):
with tf.GradientTape() as tape:
#对img进行梯度变换
tape.watch(img)
loss=calc_loss(img,model)
#计算损失相对于输入图像的像素的梯度
gradients = tape.gradient(loss,img)
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
#梯度上升,损失越大,所以是加,而不是减
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
if(verbose ==1):
if((n+1)%10==0):
print("step {}/{},loss {}".format(n+1,steps,loss))
return img
#图片预处理
img = tf.keras.applications.inception_v3.preprocess_input(img_noise)
img = tf.convert_to_tensor(img)
import time
star = time.time()
dream_img=render_deepdream(dream_model,img,steps=200)
print(time.time()-star)
dream_img = normalize_image(dream_img)
show_image(dream_img)
import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
##保存图片
def save_image(img,file_name):
PIL.Image.fromarray(np.array(img)).save(file_name)
##定义噪声图片
img_noise = np.random.uniform(size=(300,300,3))+100.##300X300的三通道图片
img_noise = img_noise.astype(np.float32)
show_image(normalize_image(img_noise))
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
layer_name="conv2d_85"
layers = base_model.get_layer(layer_name).output
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
##计算损失,与单个通道相差就在于计算loss.
def calc_loss(img,model):
channel =[13,19]#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
losses=[]
for cn in channel:
act = layer_activations[:,:,:,cn]
loss = tf.math.reduce_mean(act)##要使loss越来越大
losses.append(loss)
return tf.reduce_sum(losses)
## 图像优化过程
def render_deepdream(model,img,steps=100,step_size=0.01,verbose=1):
for n in tf.range(steps):
with tf.GradientTape() as tape:
#对img进行梯度变换
tape.watch(img)
loss=calc_loss(img,model)
#计算损失相对于输入图像的像素的梯度
gradients = tape.gradient(loss,img)
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
#梯度上升,损失越大,所以是加,而不是减
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
if(verbose ==1):
if((n+1)%10==0):
print("step {}/{},loss {}".format(n+1,steps,loss))
return img
#图片预处理
img = tf.keras.applications.inception_v3.preprocess_input(img_noise)
img = tf.convert_to_tensor(img)
import time
star = time.time()
dream_img=render_deepdream(dream_model,img,steps=200)
print(time.time()-star)
show_image(normalize_image(dream_img))
import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
##定义噪声图片
img_noise = np.random.uniform(size=(300,300,3))+100.##300X300的三通道图片
img_noise = img_noise.astype(np.float32)
show_image(normalize_image(img_noise))
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
#选择需要优化的层
layer_name=["mixed3","mixed5"]
layers = [base_model.get_layer(name).output for name in layer_name]
layers
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
##计算损失,与单个通道相差就在于计算loss.
def calc_loss(img,model):
#channel =[13,19]#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
#因为是全通道,所以不需要选择通道了
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
losses=[]
for act in layer_activations:
loss = tf.math.reduce_mean(act)##要使loss越来越大
losses.append(loss)
return tf.reduce_sum(losses)
## 图像优化过程
def render_deepdream(model,img,steps=100,step_size=0.01,verbose=1):
for n in tf.range(steps):
with tf.GradientTape() as tape:
#对img进行梯度变换
tape.watch(img)
loss=calc_loss(img,model)
#计算损失相对于输入图像的像素的梯度
gradients = tape.gradient(loss,img)
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
#梯度上升,损失越大,所以是加,而不是减
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
if(verbose ==1):
if((n+1)%10==0):
print("step {}/{},loss {}".format(n+1,steps,loss))
return img
#图片预处理
img = tf.keras.applications.inception_v3.preprocess_input(img_noise)
img = tf.convert_to_tensor(img)
###
import time
star = time.time()
dream_img=render_deepdream(dream_model,img,steps=200)
print(time.time()-star)
show_image(normalize_image(dream_img))
import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
##读取图片,可以设置图片的最大尺寸
def read_image(file_name,max_dim=None):
img = PIL.Image.open(file_name)
if max_dim:
img.thumbnail((max_dim,max_dim))
return np.array(img)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
original_img=read_image("IMG_20170713_091522.jpg",max_dim=500)
show_image(original_img)
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
#选择需要优化的层
layer_name=["mixed3","mixed5"]
layers = [base_model.get_layer(name).output for name in layer_name]
layers
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
##计算损失,与单个通道相差就在于计算loss.
def calc_loss(img,model):
#channel =[13,19]#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
#因为是全通道,所以不需要选择通道了
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
losses=[]
for act in layer_activations:
loss = tf.math.reduce_mean(act)##要使loss越来越大
losses.append(loss)
return tf.reduce_sum(losses)
## 图像优化过程
def render_deepdream(model,img,steps=100,step_size=0.01,verbose=1):
for n in tf.range(steps):
with tf.GradientTape() as tape:
#对img进行梯度变换
tape.watch(img)
loss=calc_loss(img,model)
#计算损失相对于输入图像的像素的梯度
gradients = tape.gradient(loss,img)
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
#梯度上升,损失越大,所以是加,而不是减
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
if(verbose ==1):
if((n+1)%10==0):
print("step {}/{},loss {}".format(n+1,steps,loss))
return img
#图片预处理
img = tf.keras.applications.inception_v3.preprocess_input(original_img)
img = tf.convert_to_tensor(img)
###
import time
star = time.time()
dream_img=render_deepdream(dream_model,img,steps=200)
print(time.time()-star)
show_image(normalize_image(dream_img))
import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
##读取图片,可以设置图片的最大尺寸
def read_image(file_name,max_dim=None):
img = PIL.Image.open(file_name)
if max_dim:
img.thumbnail((max_dim,max_dim))
return np.array(img)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
original_img=read_image("IMG_20170713_091522.jpg",max_dim=500)
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
#选择需要优化的层
layer_name=["mixed3","mixed5","mixed7"]
layers = [base_model.get_layer(name).output for name in layer_name]
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
##计算损失,与单个通道相差就在于计算loss.
def calc_loss(img,model):
#channel =[13,19]#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
#因为是全通道,所以不需要选择通道了
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
losses=[]
for act in layer_activations:
loss = tf.math.reduce_mean(act)##要使loss越来越大
losses.append(loss)
return tf.reduce_sum(losses)
## 图像优化过程
def render_deepdream(model,img,steps=100,step_size=0.01,verbose=1):
for n in tf.range(steps):
with tf.GradientTape() as tape:
#对img进行梯度变换
tape.watch(img)
loss=calc_loss(img,model)
#计算损失相对于输入图像的像素的梯度
gradients = tape.gradient(loss,img)
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
#梯度上升,损失越大,所以是加,而不是减
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
if(verbose ==1):
if((n+1)%10==0):
print("step {}/{},loss {}".format(n+1,steps,loss))
return img
import time
star = time.time()
#图片预处理
Scale=1.3
img = tf.keras.applications.inception_v3.preprocess_input(original_img)
img = tf.convert_to_tensor(img)
initial_shape=tf.shape(img)[:-1]
##从小到大比例进行多次优化过程
for each in range(-2,3):
new_size=tf.cast(tf.convert_to_tensor(initial_shape),tf.float32)*(Scale**each)
img=tf.image.resize(img,tf.cast(new_size,tf.int32))
img=render_deepdream(dream_model,img)
img = tf.image.resize(img,initial_shape)
print(time.time()-star)
show_image(normalize_image(img))
import tensorflow as tf
import numpy as np
import IPython.display as display
import PIL.Image
from tensorflow.keras.preprocessing import image
##定义图像移动函数
def random_roll(img,maxroll=512):
shift=tf.random.uniform(shape=[2],minval=-maxroll,maxval=maxroll,dtype=tf.int32)
#print(shift)
shift_down,shife_right=shift[0],shift[1]
#print(shift_down,shife_right)
img_rolled=tf.roll(tf.roll(img,shife_right,axis=1),shift_down,axis=0)
return shift_down,shife_right,img_rolled
##读取图片,可以设置图片的最大尺寸
def read_image(file_name,max_dim=None):
img = PIL.Image.open(file_name)
if max_dim:
img.thumbnail((max_dim,max_dim))
return np.array(img)
## 图像可视化
def show_image(img):
display.display(PIL.Image.fromarray(np.array(img)))
## 图像标准化
def normalize_image(img):
img = 255*(img+1.0)/2.0
return tf.cast(img,tf.uint8)
original_img=read_image("IMG_20170713_091522.jpg",max_dim=550)
shift_down,shife_right,img_rolled=random_roll(np.array(original_img))
show_image(img_rolled)
##构建模型,tf.keras.applications包括许多预训练好的模型,我们用InceptionV3模型。去掉顶层,这样可以接受新的训练数据的shape
base_model = tf.keras.applications.InceptionV3(include_top=False,weights="imagenet")
#选择需要优化的层
layer_name=["mixed3","mixed5"]
layers = [base_model.get_layer(name).output for name in layer_name]
dream_model = tf.keras.Model(inputs=base_model.input,outputs=layers)
##计算损失,与单个通道相差就在于计算loss.
def calc_loss(img,model):
#channel =[13,19]#不能超过320,因为<tf.Tensor 'conv2d_85/Identity:0' shape=(None, None, None, 320) dtype=float32>,最多320个通道
#由(300,300,3)变为(1,300,300,3)
#因为是全通道,所以不需要选择通道了
img=tf.expand_dims(img,axis=0)
layer_activations=model(img)
losses=[]
for act in layer_activations:
loss = tf.math.reduce_mean(act)##要使loss越来越大
losses.append(loss)
return tf.reduce_sum(losses)
def get_tiled_gradients(model,img,tile_size=150):
shift_down,shife_right,img_rolled=random_roll(img,tile_size)
gradients=tf.zeros_like(img_rolled)##初始化梯度
xs=tf.range(0,img_rolled.shape[0],tile_size)
ys=tf.range(0,img_rolled.shape[1],tile_size)
for x in xs:
for y in ys:
with tf.GradientTape() as tape:
tape.watch(img_rolled)
img_tile=img_rolled[x:x+tile_size,y:y+tile_size]#从图像中提取该图块
loss=calc_loss(img_tile,model)
gradients=gradients+tape.gradient(loss,img_rolled)##更新梯度
gradients=tf.roll(tf.roll(gradients,-shife_right,axis=1),-shift_down,axis=0)##将图块放回到原来的位置
#归一化梯度值
gradients /= tf.math.reduce_std(gradients)+1e-8
return gradients
## 图像优化过程
def render_deepdream_with_octaves(model,img,steps_per_octave=100,step_size=0.01,octaves=range(-2,3),Scale=1.3):
initial_shape=img.shape[:-1]
for each in octaves:
new_size=tf.cast(tf.convert_to_tensor(initial_shape),tf.float32)*(Scale**each)
img=tf.image.resize(img,tf.cast(new_size,tf.int32))
for step in tf.range(steps_per_octave):
gradients=get_tiled_gradients(model,img)
img=img+gradients*step_size
img=tf.clip_by_value(img,-1,1)#让输出在-1,+1之间
img = tf.image.resize(img,initial_shape)
result=normalize_image(img)
return result
import time
star = time.time()
#图片预处理
img = tf.keras.applications.inception_v3.preprocess_input(original_img)
img = tf.convert_to_tensor(img)
img=render_deepdream_with_octaves(dream_model,img)
print(time.time()-star)
show_image(img)
##保存图片
def save_image(img,file_name):
PIL.Image.fromarray(np.array(img)).save(file_name)
save_image(img,"new.jpg")